import assert from "assert";
import * as des from "../";
import * as fixtures from "./fixtures";
'use strict';
var utils = des.utils;
var bin = fixtures.bin;
describe('utils', function () {
    describe('IP', function () {
        it('should permute properly', function () {
            var out = new Array(2);
            var inp = [
                bin('00000001 00100011 01000101 01100111'),
                bin('10001001 10101011 11001101 11101111')
            ];
            utils.ip(inp[0], inp[1], out, 0);
            var expected = [
                bin('11001100 00000000 11001100 11111111'),
                bin('11110000 10101010 11110000 10101010')
            ];
            assert.deepEqual(out, expected);
        });
        it('should rev-permute properly', function () {
            var out = new Array(2);
            var inp = [
                bin('11001100 00000000 11001100 11111111'),
                bin('11110000 10101010 11110000 10101010')
            ];
            utils.rip(inp[0], inp[1], out, 0);
            var expected = [
                bin('00000001 00100011 01000101 01100111'),
                bin('10001001 10101011 11001101 11101111')
            ];
            assert.deepEqual(out, expected);
        });
    });
    describe('PC1', function () {
        it('should permute properly', function () {
            var out = new Array(2);
            var inp = [
                bin('00010011 00110100 01010111 01111001'),
                bin('10011011 10111100 11011111 11110001')
            ];
            utils.pc1(inp[0], inp[1], out, 0);
            var expected = [
                bin('1111000 0110011 0010101 0101111'),
                bin('0101010 1011001 1001111 0001111')
            ];
            assert.deepEqual(out, expected);
        });
    });
    describe('r28shl', function () {
        it('should shl properly', function () {
            assert.equal(utils.r28shl(bin('1111000011001100101010101111'), 1), bin('1110000110011001010101011111'));
            assert.equal(utils.r28shl(bin('0101010101100110011110001111'), 1), bin('1010101011001100111100011110'));
            assert.equal(utils.r28shl(bin('1111000011001100101010101111'), 4), bin('0000110011001010101011111111'));
            assert.equal(utils.r28shl(bin('0101010101100110011110001111'), 4), bin('0101011001100111100011110101'));
        });
    });
    describe('PC2', function () {
        it('should permute properly', function () {
            var out = new Array(2);
            var inp = [
                bin('1110000 1100110 0101010 1011111'),
                bin('1010101 0110011 0011110 0011110')
            ];
            utils.pc2(inp[0], inp[1], out, 0);
            var expected = [
                bin('000110 110000 001011 101111'),
                bin('111111 000111 000001 110010')
            ];
            assert.deepEqual(out, expected);
        });
    });
    describe('readUInt32BE', function () {
        it('should read number properly', function () {
            var a = [0xde, 0xad, 0xbe, 0xef];
            var o = utils.readUInt32BE(a, 0);
            assert.equal(o, 0xdeadbeef);
        });
    });
    describe('writeUInt32BE', function () {
        it('should read number properly', function () {
            var a = [0, 0, 0, 0];
            utils.writeUInt32BE(a, 0xdeadbeef, 0);
            var expected = [0xde, 0xad, 0xbe, 0xef];
            assert.deepEqual(a, expected);
        });
    });
    describe('expand', function () {
        it('should expand', function () {
            var out = [0, 0];
            utils.expand(bin('1111 0000 1010 1010 1111 0000 1010 1010'), out, 0);
            var expected = [
                bin('011110 100001 010101 010101'),
                bin('011110 100001 010101 010101')
            ];
            assert.deepEqual(out, expected);
        });
        it('should expand with low 1', function () {
            var out = [0, 0];
            utils.expand(bin('1111 0000 1010 1010 1111 0000 1010 1011'), out, 0);
            var expected = [
                bin('111110 100001 010101 010101'),
                bin('011110 100001 010101 010111')
            ];
            assert.deepEqual(out, expected);
        });
        it('should expand with low 1', function () {
            var out = [0, 0];
            utils.expand(bin('10100010 01011100 00001011 11110100'), out, 0);
            var expected = [
                bin('010100 000100 001011 111000'),
                bin('000001 010111 111110 101001')
            ];
            assert.deepEqual(out, expected);
        });
    });
    describe('substitute', function () {
        it('should substitute', function () {
            var input = [
                bin('011000 010001 011110 111010'),
                bin('100001 100110 010100 100111')
            ];
            var output = utils.substitute(input[0], input[1]);
            assert.equal(output, bin('0101 1100 1000 0010 1011 0101 1001 0111'));
        });
    });
    describe('permute', function () {
        it('should permute', function () {
            var output = utils.permute(bin('0101 1100 1000 0010 1011 0101 1001 0111'));
            assert.equal(output, bin('0010 0011 0100 1010 1010 1001 1011 1011'));
        });
    });
});
